package models

import (
	"github.com/goccy/go-json"
	"gorm.io/gorm"
)

type Task struct {
	TaskId     string          `gorm:"type:varchar(100);column:task_id;comment:任务id" json:"task_id"`
	TaskName   string          `gorm:"type:varchar(100);column:task_name;comment:任务名称" json:"task_name"`
	TaskStatus string          `gorm:"type:varchar(50);column:task_status;comment:任务状态" json:"task_status"`
	TaskKey    string          `gorm:"type:varchar(255);column:task_key;comment:任务key;uniqueIndex" json:"task_key"`
	TaskData   json.RawMessage `gorm:"type:json;column:task_data;comment:任务数据" json:"task_data"`
	NotifyUrl  string          `gorm:"_" json:"notify_url"`
	gorm.Model `gorm:"embedded"`
}

func (t *Task) FindByRawSQL(db *gorm.DB, query string, args ...interface{}) error {
	//TODO implement me
	panic("implement me")
}

func (t *Task) GetByField(db *gorm.DB, field string, value interface{}) error {
	result := db.Where(map[string]interface{}{field: value}).First(t)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

// Task 任务表 CRUD 实现
func (t *Task) Create(db *gorm.DB) error {
	// 校验必填字段（任务ID、名称、状态、Key不可为空）
	if t.TaskId == "" || t.TaskName == "" || t.TaskStatus == "" || t.TaskKey == "" {
		return gorm.ErrInvalidData
	}
	// 处理 TaskData（确保JSON格式合法，可选）
	if t.TaskData != nil && !json.Valid(t.TaskData) {
		return gorm.ErrInvalidData
	}
	return db.Create(t).Error
}

func (t *Task) Update(db *gorm.DB) error {
	// 仅更新允许修改的字段（排除TaskId/TaskKey，避免唯一索引冲突）
	updatable := map[string]interface{}{
		"task_name":   t.TaskName,
		"task_status": t.TaskStatus,
		"task_data":   t.TaskData,
		// NotifyUrl为gorm:"_"，不存入数据库，无需更新
	}
	return db.Model(t).Where("task_id = ?", t.TaskId).Updates(updatable).Error
}

func (t *Task) Delete(db *gorm.DB, id uint) error {
	// 注意：此处id为gorm.Model的ID（自增主键），若需按TaskId删除可调整参数
	return db.Delete(&Task{}, "id = ?", id).Error
}

func (t *Task) GetByID(db *gorm.DB, id uint) error {
	// 支持按gorm.ID或TaskId查询（此处按ID，需按TaskId查询可改Where条件）
	return db.First(t, "id = ?", id).Error
}

func (t *Task) List(db *gorm.DB, page, pageSize int) ([]interface{}, int64, error) {
	var total int64
	var tasks []Task

	// 构建筛选条件：支持按任务状态、TaskKey筛选
	query := db.Model(&Task{})
	if t.TaskStatus != "" {
		query = query.Where("task_status = ?", t.TaskStatus)
	}
	if t.TaskKey != "" {
		query = query.Where("task_key = ?", t.TaskKey)
	}

	// 统计总数
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, err
	}

	// 分页查询（按创建时间倒序，最新任务在前）
	offset := (page - 1) * pageSize
	if err := query.Offset(offset).Limit(pageSize).Order("created_at DESC").Find(&tasks).Error; err != nil {
		return nil, 0, err
	}

	// 转换为接口切片返回
	result := make([]interface{}, len(tasks))
	for i, v := range tasks {
		result[i] = v
	}
	return result, total, nil
}

type TaskKey struct {
	TaskName   string `gorm:"type:varchar(100);column:task_name;comment:任务名称" json:"task_name"`
	TaskKey    string `gorm:"type:varchar(255);column:task_key;comment:任务key" json:"task_key"`
	NotifyUrl  string `gorm:"_" json:"notify_url"`
	gorm.Model `gorm:"embedded"`
}

func (tk *TaskKey) FindByRawSQL(db *gorm.DB, query string, args ...interface{}) error {
	//TODO implement me
	panic("implement me")
}

func (tk *TaskKey) GetByField(db *gorm.DB, field string, value interface{}) error {
	result := db.Where(map[string]interface{}{field: value}).First(tk)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

// TaskKey 任务Key表 CRUD 实现
func (tk *TaskKey) Create(db *gorm.DB) error {
	// 校验必填字段（任务名称、Key不可为空）
	if tk.TaskName == "" || tk.TaskKey == "" {
		return gorm.ErrInvalidData
	}
	return db.Create(tk).Error
}

func (tk *TaskKey) Update(db *gorm.DB) error {
	// NotifyUrl为gorm:"_"，不存入数据库，仅更新TaskName/TaskKey
	return db.Model(tk).Updates(map[string]interface{}{
		"task_name": tk.TaskName,
		"task_key":  tk.TaskKey,
	}).Error
}

func (tk *TaskKey) Delete(db *gorm.DB, id uint) error {
	return db.Delete(&TaskKey{}, id).Error
}

func (tk *TaskKey) GetByID(db *gorm.DB, id uint) error {
	return db.First(tk, id).Error
}

func (tk *TaskKey) List(db *gorm.DB, page, pageSize int) ([]interface{}, int64, error) {
	var total int64
	var taskKeys []TaskKey

	// 筛选条件：支持按TaskName/TaskKey模糊查询
	query := db.Model(&TaskKey{})
	if tk.TaskName != "" {
		query = query.Where("task_name LIKE ?", "%"+tk.TaskName+"%")
	}
	if tk.TaskKey != "" {
		query = query.Where("task_key = ?", tk.TaskKey)
	}

	if err := query.Count(&total).Error; err != nil {
		return nil, 0, err
	}

	offset := (page - 1) * pageSize
	if err := query.Offset(offset).Limit(pageSize).Order("created_at DESC").Find(&taskKeys).Error; err != nil {
		return nil, 0, err
	}

	result := make([]interface{}, len(taskKeys))
	for i, v := range taskKeys {
		result[i] = v
	}
	return result, total, nil
}

type Area struct {
	CityName   string `gorm:"type:varchar(50);column:city_name;comment:城市名称" json:"city_name"` // 城市名称
	CityCode   string `gorm:"type:varchar(10);column:city_code;comment:城市代码" json:"city_code"` // 城市代码
	IsHot      string `gorm:"type:enum('1','0');column:is_hot;comment:是否热门城市" json:"is_hot"`   // 是否热门城市
	gorm.Model `gorm:"embedded"`
}

func (a *Area) FindByRawSQL(db *gorm.DB, query string, args ...interface{}) error {
	//TODO implement me
	panic("implement me")
}

func (a *Area) GetByField(db *gorm.DB, field string, value interface{}) error {
	result := db.Where(map[string]interface{}{field: value}).First(a)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

// Area 城市区域表 CRUD 实现
func (a *Area) Create(db *gorm.DB) error {
	// 校验必填字段（城市名称、代码不可为空，IsHot需为'0'或'1'）
	if a.CityName == "" || a.CityCode == "" || (a.IsHot != "0" && a.IsHot != "1") {
		return gorm.ErrInvalidData
	}
	// 确保城市代码唯一（避免重复添加）
	var existArea Area
	if err := db.Where("city_code = ?", a.CityCode).First(&existArea).Error; err == nil {
		return gorm.ErrDuplicatedKey // 重复key错误
	}
	return db.Create(a).Error
}

func (a *Area) Update(db *gorm.DB) error {
	// 禁止修改CityCode（唯一标识），仅更新名称和热门状态
	return db.Model(a).Where("city_code = ?", a.CityCode).Updates(map[string]interface{}{
		"city_name": a.CityName,
		"is_hot":    a.IsHot,
	}).Error
}

func (a *Area) Delete(db *gorm.DB, id uint) error {
	return db.Delete(&Area{}, id).Error
}

func (a *Area) GetByID(db *gorm.DB, id uint) error {
	return db.First(a, id).Error
}

func (a *Area) List(db *gorm.DB, page, pageSize int) ([]interface{}, int64, error) {
	var total int64
	var areas []Area

	// 筛选条件：支持按热门状态、城市名称模糊查询
	query := db.Model(&Area{})
	if a.IsHot != "" {
		query = query.Where("is_hot = ?", a.IsHot)
	}
	if a.CityName != "" {
		query = query.Where("city_name LIKE ?", "%"+a.CityName+"%")
	}

	if err := query.Count(&total).Error; err != nil {
		return nil, 0, err
	}

	// 按热门状态（热门在前）+ 城市名称排序
	offset := (page - 1) * pageSize
	if err := query.Offset(offset).Limit(pageSize).
		Order("is_hot DESC").Order("city_name ASC").Find(&areas).Error; err != nil {
		return nil, 0, err
	}

	result := make([]interface{}, len(areas))
	for i, v := range areas {
		result[i] = v
	}
	return result, total, nil
}

// Bossmodelss 定义了一个Boss模型的结构体
type Boss struct {
	JobName        string `gorm:"type:varchar(100);column:job_name;comment:工作名称" json:"JobName"`                // 工作名称
	CityName       string `gorm:"type:varchar(100);column:city_name;comment:城市名称" json:"CityName"`              // 城市名称
	JobDegree      string `gorm:"type:varchar(100);column:job_degree;comment:文凭" json:"JobDegree"`              // 文凭
	JobExperience  string `gorm:"type:varchar(100);column:job_experience;comment:工作经验" json:"JobExperience"`    // 工作经验
	Address        string `gorm:"type:varchar(100);column:address;comment:地址" json:"Address"`                   // 地址
	SalaryDesc     string `gorm:"type:varchar(100);column:salary_desc;comment:薪资" json:"SalaryDesc"`            // 薪资
	BossName       string `gorm:"type:varchar(100);column:boss_name;comment:招聘人" json:"BossName"`               // 招聘人
	BossTitle      string `gorm:"type:varchar(100);column:boss_title;comment:招聘人职位" json:"BossTitle"`           // 招聘人职位
	BrandName      string `gorm:"type:varchar(100);column:brand_name;comment:招聘公司名称" json:"BrandName"`          // 招聘公司名称
	BrandScaleName string `gorm:"type:varchar(100);column:brand_scale_name;comment:公司规模" json:"BrandScaleName"` // 公司规模
	BrandIndustry  string `gorm:"type:varchar(100);column:brand_industry;comment:公司类型" json:"BrandIndustry"`    // 公司类型
	BrandStageName string `gorm:"type:varchar(100);column:brand_stage_name;comment:公司现状" json:"BrandStageName"` // 公司现状
	WelfareList    string `gorm:"type:varchar(100);column:welfare_list;comment:公司福利" json:"WelfareList"`        // 公司福利
	JobDes         string `gorm:"type:longtext;column:zwms;comment:职位描述" json:"Zwms"`                           // 职位描述
	GwZz           string `gorm:"type:longtext;column:gwzz;comment:岗位职责" json:"GwZz"`                           // 岗位职责
	gorm.Model     `gorm:"embedded"`
}

func (b *Boss) FindByRawSQL(db *gorm.DB, query string, args ...interface{}) error {
	//TODO implement me
	panic("implement me")
}

// Boss 招聘信息表 CRUD 实现
func (b *Boss) Create(db *gorm.DB) error {
	// 校验核心必填字段（工作名称、城市、薪资、招聘人、公司名称不可为空）
	requiredFields := map[string]string{
		"JobName":    b.JobName,
		"CityName":   b.CityName,
		"SalaryDesc": b.SalaryDesc,
		"BossName":   b.BossName,
		"BrandName":  b.BrandName,
	}
	for _, val := range requiredFields {
		if val == "" {
			return gorm.ErrInvalidData
		}
	}
	return db.Create(b).Error
}

func (b *Boss) Update(db *gorm.DB) error {
	// 支持全字段更新（排除gorm.Model的默认字段，由ORM自动维护）
	return db.Model(b).Updates(map[string]interface{}{
		"job_name":         b.JobName,
		"city_name":        b.CityName,
		"job_degree":       b.JobDegree,
		"job_experience":   b.JobExperience,
		"address":          b.Address,
		"salary_desc":      b.SalaryDesc,
		"boss_name":        b.BossName,
		"boss_title":       b.BossTitle,
		"brand_name":       b.BrandName,
		"brand_scale_name": b.BrandScaleName,
		"brand_industry":   b.BrandIndustry,
		"brand_stage_name": b.BrandStageName,
		"welfare_list":     b.WelfareList,
		"zwms":             b.JobDes, // 数据库字段为zwms，对应结构体JobDes
		"gwzz":             b.GwZz,   // 数据库字段为gwzz，对应结构体GwZz
	}).Error
}

func (b *Boss) Delete(db *gorm.DB, id uint) error {
	return db.Delete(&Boss{}, id).Error
}

func (b *Boss) GetByID(db *gorm.DB, id uint) error {
	return db.First(b, id).Error
}

func (b *Boss) GetByField(db *gorm.DB, field string, value interface{}) error {
	result := db.Where(map[string]interface{}{field: value}).First(b)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func (b *Boss) List(db *gorm.DB, page, pageSize int) ([]interface{}, int64, error) {
	var total int64
	var bosses []Boss

	// 筛选条件：支持按城市、薪资、公司类型、工作经验筛选
	query := db.Model(&Boss{})
	if b.CityName != "" {
		query = query.Where("city_name = ?", b.CityName)
	}
	if b.SalaryDesc != "" {
		query = query.Where("salary_desc LIKE ?", "%"+b.SalaryDesc+"%")
	}
	if b.BrandIndustry != "" {
		query = query.Where("brand_industry = ?", b.BrandIndustry)
	}
	if b.JobExperience != "" {
		query = query.Where("job_experience = ?", b.JobExperience)
	}

	if err := query.Count(&total).Error; err != nil {
		return nil, 0, err
	}

	// 按创建时间倒序（最新招聘信息在前）
	offset := (page - 1) * pageSize
	if err := query.Offset(offset).Limit(pageSize).Order("created_at DESC").Find(&bosses).Error; err != nil {
		return nil, 0, err
	}

	result := make([]interface{}, len(bosses))
	for i, v := range bosses {
		result[i] = v
	}
	return result, total, nil
}
